Kotlin

Intro

• Moderne, Concis
• Orienté Objet / Fonctionnel
• Java Interop
• Développé par JetBrains
• Kotlin everywhere: JVM, Backend, JS, KTS, iOS...

Typage statique inféré

// explicit
val myInt: Int = 1

// implicit
val myInt = 1
val myString = "coucou"
val myUser = User()

val myList = listOf(0f, 0.5f, 1f) // List<Float>
val emptyList = emptyList<Double>() // List<Double>

Mutabilité

// valeur primitive fixée à la compilation qui ne peut pas changer
const val APP_ID = 42424242

// valeur donnée à l'execution qui ne peut pas changer ensuite
val user = 0
user = 1 //  ne compile pas

// valeur qui peut changer
var myMutableVariable = 0
myMutableVariable = 1

// structure de données mutables ou immutables, ex: listes
val immutableList = listOf(1, 2, 3)
immutableList.add(4) //  la méthode n'existe pas

val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4) // 

Nullabilité

var user: User? = null
user = getUser()

// soft unwrap: exécute ou retourne null si l'instance est null
user?.name

// force unwrap: exécute OU crash si l'instance est nulle
user!!.toString()

// elvis operator: exécute la partie à droite si la partie à gauche est null
user?.name ?: "none"

// let: extension qui permet de manipuler une instance dans une lambda
// souvent utilisé avec des instances nullables
user?.let { it.name } ?: "none"

@Nullable pour l'interopérabilité avec Java

Smart casts

var user: User?

user?.connect()

if (user != null) user.connect()

When statements

Un switch-case en plus puissant:

val primeNumbers = listOf(1, 3, 5, 7, 11, 13, 17)

val x: Any? = 13

val result = when(x) {
    null -> "x is null" //  -> smart casté comme Any
    !is Int -> "x is not an int" //  -> smart casté comme Int
    in 1..10 -> "x is between 1 and 10" // 
    !in 10..20 -> "x is not between 10 and 20" // 
    in primeNumbers -> "x is a prime" // 
    else -> "none of the above" // ignoré
}

print(result)

Loops

val list = listOf(1, 2, 3, 4, 5)

for (i in 0..4) {
  print(list[i])
}

for (element in list) {
  print(element)
}

list.forEach { element ->
  print(element)
}

// while, do while, etc

Functions

fun add(
  first: Int,
  second: Int,
) : Int {
  var result: Int
  result = first + second
  return result
}

// short syntax
fun add(first: Int, second: Int) = first + second

Classes

// declaration and primary constructor
class Student(
  login: String, // constructor argument
  public val subjects: List<Subject> = emptyList(), // public property
) : User(login) { // parent constructor

    private val email: String // private property

    // secondary constructor
    constructor(firstname: String, lastname: String) : this("$firstname_$lastname")

    init { // additional constructor logic
      email = "$login@school.com"
    }
}

// classes are final by default: `open` allows inheritage
open class User(val login: String) {}

Object

Permet de créer facilement un Singleton (~static class)

object Analytics {
  fun trackLoginEvent() { ... }
}

// remplace le `static class` Java:
Analytics.trackLoginEvent()

Companion object

Permet d'avoir l'équivalent des membres static en Java:

class Math {

  companion object {
    const val PI = 3.14159265359
  }
}

Math.PI // interop java: MyClass.Companion.MY_CONSTANT

Data class

equals(), toString(), hashCode(), copy() et destructuration sans rien coder !

data class Point(val x: Float, val y: Float)

val pointA = Point(1.0f, 2.0f)

val (x, y) = pointA

val pointB = pointA.copy(y = 1.0f)

pointB.toString() // Point(x=1.0f, y=1.0f)

val pointC = Point(1.0f, 2.0f)
pointA == pointC //  true

Enum class

enum class Color {
  RED, GREEN, BLUE
}

enum class Color(val rgb: Int) {
  RED(0xFF0000),
  GREEN(0x00FF00),
  BLUE(0x0000FF),
}

Sealed class

Classes ayant un nombre de sous classes défini et limité

sealed class Result {
  class Success(val value: Any) : Result()
  class Failure(val error: Error) : Result()
  object Loading : Result()
}

// utile avec les smart cast
when (result) {
  is Result.Success -> display(result.value)
  is Result.Failure -> log(result.error)
}

Extensions

fun String.capitalize(): String { // function
  return ...
}

val String.titlecased // property
  get() = this.capitalize()

"hello".capitalize() //  "Hello"

Lambdas

Blocs d'execution qui se manipulent en tant que variables:

val add: (Int, Int) -> Int = { a, b -> a + b }
add(1, 2) //  3

fun applyToSelf(number: Int, operation: (Int, Int) -> Int) {
    operation(number, number)
 }

applyToSelf(4, add) // 8
applyToSelf(3) { a, b -> a - b } // 0

// for Single Abstract Method (SAM) interface
button.setOnClickListener { view -> ... }

Delegates

class DraggableButton(
  clickListener: ClickListener,
  dragListener: DragListener
) : ClickListener by clickListener, DragListener by dragListener

val lazyUser: User by lazy { getCurrentUser() }

Démo

Kotlin Playground

Swift

Très similaire:

• Typage statique inféré
• Optionals
• Closure
• Extensions
• ...

https://nilhcem.com/swift-is-like-kotlin/

Petites nuances: Structs, Automatic Reference Counting, ...